package com.jn.jackson.utils;

import android.content.Context;
import android.content.res.AssetManager;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class JsonUtils {

    /**
     * 获取assets目录下json文件中的字符串
     *
     * @param context
     * @param fileName 文件名
     * @return
     */
    public static String getJsonFromAssets(Context context, String fileName) {
        //将json数据变成字符串

        StringBuilder stringBuilder = new StringBuilder();
        try {
            //获取assets资源管理器
            AssetManager assetManager = context.getAssets();
            //通过管理器打开文件并读取
            BufferedReader bf = new BufferedReader(new InputStreamReader(
                    assetManager.open(fileName)));
            String line;
            while ((line = bf.readLine()) != null) {
                stringBuilder.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return stringBuilder.toString().trim();
    }

    /**
     * 递归搜索 JSON 中所有匹配 key 的值
     *
     * @param json      复杂嵌套的 JSON 字符串
     * @param targetKey 目标 key
     * @return 所有匹配 key 的值列表（支持 key 重复出现）
     */
    public static List<String> getKeyRecursively(String json, String targetKey) {
        List<String> result = new ArrayList<>();
        try {
            // 1. 解析 JSON 为 JsonNode 树形结构
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode rootNode = objectMapper.readTree(json);

            // 2. 开始递归遍历（从根节点出发）
            traverseNode(rootNode, targetKey, result);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 递归遍历 JsonNode 节点
     *
     * @param currentNode 当前遍历的节点
     * @param targetKey   目标 key
     * @param result      存储匹配结果的列表
     */
    private static void traverseNode(JsonNode currentNode, String targetKey, List<String> result) {
        // 情况 1：当前节点是对象（ObjectNode），遍历其所有字段
        if (currentNode instanceof ObjectNode) {
            ObjectNode objectNode = (ObjectNode) currentNode;
            // 获取对象的所有字段（key-value 对）
            Iterator<Map.Entry<String, JsonNode>> fields = objectNode.fields();

            while (fields.hasNext()) {
                Map.Entry<String, JsonNode> field = fields.next();
                String fieldKey = field.getKey();
                JsonNode fieldValue = field.getValue();

                // 若当前字段的 key 匹配目标 key，提取值并加入结果
                if (fieldKey.equals(targetKey)) {
                    result.add(convertNodeToString(fieldValue));
                }

                // 无论是否匹配，若字段值是对象或数组，继续递归遍历子节点
                if (fieldValue instanceof ObjectNode || fieldValue instanceof ArrayNode) {
                    traverseNode(fieldValue, targetKey, result);
                }
            }
        }

        // 情况 2：当前节点是数组（ArrayNode），遍历数组中的每个元素
        else if (currentNode instanceof ArrayNode) {
            ArrayNode arrayNode = (ArrayNode) currentNode;
            // 遍历数组的每个元素
            for (JsonNode element : arrayNode) {
                // 若元素是对象或数组，继续递归遍历
                if (element instanceof ObjectNode || element instanceof ArrayNode) {
                    traverseNode(element, targetKey, result);
                }
            }
        }

        // 情况 3：当前节点是基本类型（字符串、数字等），无需继续遍历（非对象/数组无子节点）
    }

    /**
     * 将 JsonNode 转换为易于阅读的字符串（根据节点类型适配）
     *
     * @param node 要转换的节点
     * @return 转换后的字符串
     */
    private static String convertNodeToString(JsonNode node) {
        if (node.isTextual()) {
            return node.asText(); // 字符串类型
        } else if (node.isNumber()) {
            return node.numberValue().toString(); // 数字类型
        } else if (node.isBoolean()) {
            return node.asBoolean() ? "true" : "false"; // 布尔类型
        } else if (node.isObject() || node.isArray()) {
            // 若值是对象/数组，返回其 JSON 字符串形式
            return node.toString();
        } else {
            return "null"; // 其他类型（如 null）
        }
    }
}
